home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / lists / mint / l_1599 / 1415 < prev    next >
Encoding:
Internet Message Format  |  1994-08-27  |  11.0 KB
  1. From: Kay Roemer <roemer@informatik.uni-frankfurt.de>
  2. Posted-Date: Fri, 20 May 94 8:38:47 MESZ
  3. Received-Date: Fri, 20 May 94 08:38:47 +0200
  4. Message-Id: <9405200638.AA16329@hera.rbi.informatik.uni-frankfurt.de>
  5. Subject: addroottimeout() patches v2
  6. To: mint@atari.archive.umich.edu
  7. Date: Fri, 20 May 94 8:38:47 MESZ
  8. Mailer: Elm [revision: 70.85]
  9.  
  10. These are the patches that bring addroottimeout() and cancelroottimeout()
  11. to Mint 1.10.
  12.  
  13. They fix a bug in the previous release of the patches. Please update your
  14. version of Mint.
  15.  
  16. Kay.
  17.  
  18.  
  19. *** file.h.orig    Sun Mar 20 19:08:10 1994
  20. --- file.h    Wed May 18 23:01:32 1994
  21. ***************
  22. *** 243,251 ****
  23.   /* functions for adding/cancelling timeouts */
  24.       struct timeout * ARGS_ON_STACK (*addtimeout) P_((long, void (*)()));
  25.       void    ARGS_ON_STACK (*canceltimeout) P_((struct timeout *));
  26.    
  27.   /* reserved for future use */
  28. !     long    res2[7];
  29.   };
  30.   
  31.   /* flags for open() modes */
  32. --- 243,253 ----
  33.   /* functions for adding/cancelling timeouts */
  34.       struct timeout * ARGS_ON_STACK (*addtimeout) P_((long, void (*)()));
  35.       void    ARGS_ON_STACK (*canceltimeout) P_((struct timeout *));
  36. +     struct timeout * ARGS_ON_STACK (*addroottimeout) P_((long, void (*)(), short));
  37. +     void    ARGS_ON_STACK (*cancelroottimeout) P_((struct timeout *));
  38.    
  39.   /* reserved for future use */
  40. !     long    res2[5];
  41.   };
  42.   
  43.   /* flags for open() modes */
  44. *** main.c.orig    Sun Mar 20 19:07:52 1994
  45. --- main.c    Wed May 18 23:00:44 1994
  46. ***************
  47. *** 193,199 ****
  48.       strnicmp, stricmp, strlwr, strupr, ksprintf,
  49.       ms_time, unixtim, dostim,
  50.       nap, sleep, wake, wakeselect,
  51. !     denyshare, denylock, addtimeout, canceltimeout
  52.   };
  53.   
  54.   /* table of processor frame sizes in _words_ (not used on MC68000) */
  55. --- 193,200 ----
  56.       strnicmp, stricmp, strlwr, strupr, ksprintf,
  57.       ms_time, unixtim, dostim,
  58.       nap, sleep, wake, wakeselect,
  59. !     denyshare, denylock, addtimeout, canceltimeout,
  60. !     addroottimeout, cancelroottimeout
  61.   };
  62.   
  63.   /* table of processor frame sizes in _words_ (not used on MC68000) */
  64. *** proc.h.orig    Sun Mar 20 19:08:10 1994
  65. --- proc.h    Sun Mar 20 19:07:40 1994
  66. ***************
  67. *** 67,72 ****
  68. --- 67,73 ----
  69.       struct proc    *proc;
  70.       long    when;
  71.       void    (*func) P_((struct proc *)); /* function to call at timeout */
  72. +     short    flags;
  73.   } TIMEOUT;
  74.   
  75.   #ifndef GENMAGIC
  76. *** proto.h.orig    Sun Mar 20 19:08:10 1994
  77. --- proto.h    Wed May 18 22:59:42 1994
  78. ***************
  79. *** 274,281 ****
  80. --- 274,283 ----
  81.   
  82.   /* timeout.c */
  83.   TIMEOUT * ARGS_ON_STACK addtimeout P_((long delta, void (*func)(PROC *p)));
  84. + TIMEOUT * ARGS_ON_STACK addroottimeout P_((long delta, void (*func)(PROC *p), short flags));
  85.   void ARGS_ON_STACK cancelalltimeouts P_((void));
  86.   void ARGS_ON_STACK canceltimeout P_((TIMEOUT *which));
  87. + void ARGS_ON_STACK cancelroottimeout P_((TIMEOUT *which));
  88.   void ARGS_ON_STACK timeout P_((void));
  89.   void checkalarms P_((void));
  90.   void ARGS_ON_STACK nap P_((unsigned n));
  91. *** timeout.c.orig    Sun Mar 20 19:07:52 1994
  92. --- timeout.c    Wed May 18 22:58:18 1994
  93. ***************
  94. *** 19,55 ****
  95.   extern short in_kernel;    /* in main.c */
  96.   
  97.   static void unnapme P_((PROC *));
  98.   
  99. ! /*
  100. !  * addtimeout(long delta, void (*func)()): schedule a timeout for the current
  101. !  * process, to take place in "delta" milliseconds. "func" specifies a
  102. !  * function to be called at that time; the function is passed as a parameter
  103. !  * the process for which the timeout was specified (i.e. the value of
  104. !  * curproc at the time addtimeout() was called; note that this is probably
  105. !  * *not* the current process when the timeout occurs).
  106.    */
  107. ! 
  108. ! TIMEOUT *tlist;
  109.   
  110. - #define newtimeout() (TIMEOUT *)kmalloc(SIZEOF(TIMEOUT))
  111. - #define disposetimeout(t) kfree(t)
  112.   
  113. ! TIMEOUT * ARGS_ON_STACK
  114. ! addtimeout(delta, func)
  115. !     long delta;
  116. !     void (*func) P_((PROC *));
  117.   {
  118. !     TIMEOUT *t, **prev, *cur;
  119.   
  120. !     t = newtimeout();
  121.   
  122. ! /* BUG: we should have some fallback mechanism for timeouts when the
  123. !    kernel memory is exhausted
  124. !  */
  125. !     assert(t);
  126.   
  127. !     t->proc = curproc;
  128. !     t->func = func;
  129.   
  130.       cur = tlist;
  131.       prev = &tlist;
  132. --- 19,80 ----
  133.   extern short in_kernel;    /* in main.c */
  134.   
  135.   static void    unnapme P_((PROC *));
  136. + static TIMEOUT    *newtimeout P_((short));
  137. + static void    disposetimeout P_((TIMEOUT *));
  138. + static void    inserttimeout P_ ((TIMEOUT *, long));
  139. + 
  140. + #define TIMEOUTS    20    /* # of static timeout structs */
  141. + #define TIMEOUT_USED    0x01    /* timeout struct is in use */
  142. + #define TIMEOUT_STATIC    0x02    /* this is a static timeout */
  143.   
  144. ! /* This gets implizitly initialized to zero, thus the flags are
  145. !  * set up correctly.
  146.    */
  147. ! static TIMEOUT timeouts[TIMEOUTS] = { { 0, }, };
  148. ! TIMEOUT *tlist = NULL;
  149.   
  150.   
  151. ! static TIMEOUT *
  152. ! newtimeout(fromlist)
  153. !     short fromlist;
  154.   {
  155. !     TIMEOUT *t;
  156. !     short i, sr;
  157.   
  158. !     if (!fromlist) {
  159. !         t = kmalloc(SIZEOF(TIMEOUT));
  160. !         if (t) {
  161. !             t->flags = 0;
  162. !             return t;
  163. !         }
  164. !     }
  165. !     sr = spl7();
  166. !     for (i = 0; i < TIMEOUTS; ++i) {
  167. !         if (!(timeouts[i].flags & TIMEOUT_USED)) {
  168. !             timeouts[i].flags |= (TIMEOUT_STATIC|TIMEOUT_USED);
  169. !             spl(sr);
  170. !             return &timeouts[i];
  171. !         }
  172. !     }
  173. !     spl(sr);
  174. !     return 0;
  175. ! }
  176.   
  177. ! static void
  178. ! disposetimeout(t)
  179. !     TIMEOUT *t;
  180. ! {
  181. !     if (t->flags & TIMEOUT_STATIC) t->flags &= ~TIMEOUT_USED;
  182. !     else kfree(t);
  183. ! }
  184.   
  185. ! static void
  186. ! inserttimeout(t, delta)
  187. !     TIMEOUT *t;
  188. !     long delta;
  189. ! {
  190. !     TIMEOUT **prev, *cur;
  191. !     short sr = spl7();
  192.   
  193.       cur = tlist;
  194.       prev = &tlist;
  195. ***************
  196. *** 59,65 ****
  197.               t->next = cur;
  198.               t->when = delta;
  199.               *prev = t;
  200. !             return t;
  201.           }
  202.           delta -= cur->when;
  203.           prev = &cur->next;
  204. --- 84,91 ----
  205.               t->next = cur;
  206.               t->when = delta;
  207.               *prev = t;
  208. !             spl(sr);
  209. !             return;
  210.           }
  211.           delta -= cur->when;
  212.           prev = &cur->next;
  213. ***************
  214. *** 69,74 ****
  215. --- 95,167 ----
  216.       t->when = delta;
  217.       t->next = cur;
  218.       *prev = t;
  219. +     spl(sr);
  220. + }
  221. +     
  222. + /*
  223. +  * addtimeout(long delta, void (*func)()): schedule a timeout for the current
  224. +  * process, to take place in "delta" milliseconds. "func" specifies a
  225. +  * function to be called at that time; the function is passed as a parameter
  226. +  * the process for which the timeout was specified (i.e. the value of
  227. +  * curproc at the time addtimeout() was called; note that this is probably
  228. +  * *not* the current process when the timeout occurs).
  229. +  *
  230. +  * NOTE: if kernel memory is low, newtimeout() will try to get a statically
  231. +  * allocated timeout struct (fallback method).
  232. +  */
  233. + 
  234. + TIMEOUT * ARGS_ON_STACK
  235. + addtimeout(delta, func)
  236. +     long delta;
  237. +     void (*func) P_((PROC *));
  238. + {
  239. +     TIMEOUT *t;
  240. + 
  241. +     t = newtimeout(0);
  242. + 
  243. + /* BUG: we should have some fallback mechanism for timeouts when the
  244. +    kernel memory is exhausted
  245. +  */
  246. +     assert(t);
  247. + 
  248. +     t->proc = curproc;
  249. +     t->func = func;
  250. +     inserttimeout(t, delta);
  251. +     return t;
  252. + }
  253. + 
  254. + /*
  255. +  * addroottimeout(long delta, void (*)(PROC *), short flags);
  256. +  * Same as addtimeout(), except that the timeout is attached to Pid 0 (MiNT).
  257. +  * This means the timeout won't be cancelled if the process which was
  258. +  * running at the time addroottimeout() was called exits.
  259. +  *
  260. +  * Currently only bit 0 of `flags' is used. Meaning:
  261. +  * Bit 0 set: Call from interrupt (cannot use kmalloc, use statically
  262. +  *    allocated `struct timeout' instead).
  263. +  * Bit 0 clear: Not called from interrupt, can use kmalloc.
  264. +  *
  265. +  * Thus addroottimeout() can be called from interrupts (bit 0 of flags set),
  266. +  * which makes it *extremly* useful for device drivers.
  267. +  * A serial device driver would make an addroottimeout(0, check_keys, 1)
  268. +  * if some bytes have arrived.
  269. +  * check_keys() is then called at the next context switch, can use all
  270. +  * the kernel functions and can do time cosuming jobs.
  271. +  */
  272. + 
  273. + TIMEOUT * ARGS_ON_STACK
  274. + addroottimeout(delta, func, flags)
  275. +     long delta;
  276. +     void (*func) P_((PROC *));
  277. +     short flags;
  278. + {
  279. +     TIMEOUT *t;
  280. + 
  281. +     t = newtimeout(flags & 1);
  282. +     if (!t) return NULL;
  283. +     t->proc = rootproc;
  284. +     t->func = func;
  285. +     inserttimeout(t, delta);
  286.       return t;
  287.   }
  288.   
  289. ***************
  290. *** 82,87 ****
  291. --- 175,181 ----
  292.   {
  293.       TIMEOUT *cur, **prev, *old;
  294.       long delta;
  295. +     short sr = spl7 ();
  296.   
  297.       cur = tlist;
  298.       prev = &tlist;
  299. ***************
  300. *** 91,103 ****
  301. --- 185,203 ----
  302.               old = cur;
  303.               *prev = cur = cur->next;
  304.               if (cur) cur->when += delta;
  305. +             spl(sr);
  306.               disposetimeout(old);
  307. +             sr = spl7();
  308. +         /* ++kay: just in case an interrupt handler installed a
  309. +          * timeout right after `prev' and before `cur' */
  310. +             cur = *prev;
  311.           }
  312.           else {
  313.               prev = &cur->next;
  314.               cur = cur->next;
  315.           }
  316.       }
  317. +     spl (sr);
  318.   }
  319.   
  320.   /*
  321. ***************
  322. *** 115,133 ****
  323.       TIMEOUT *this;
  324.   {
  325.       TIMEOUT *cur, **prev;
  326.   
  327.       prev = &tlist;
  328.       for (cur = tlist; cur; cur = cur->next) {
  329. !         if (cur == this && cur->proc == curproc) {
  330.               *prev = cur->next;
  331.               if (cur->next) {
  332.                   cur->next->when += this->when;
  333.               }
  334.               disposetimeout(this);
  335. !             break;
  336.           }
  337.           prev = &cur->next;
  338.       }
  339.   }
  340.   
  341.   /*
  342. --- 215,259 ----
  343.       TIMEOUT *this;
  344.   {
  345.       TIMEOUT *cur, **prev;
  346. +     short sr = spl7();
  347. +     
  348. +     prev = &tlist;
  349. +     for (cur = tlist; cur; cur = cur->next) {
  350. +         if (cur == this && (cur->proc == curproc)) {
  351. +             *prev = cur->next;
  352. +             if (cur->next) {
  353. +                 cur->next->when += this->when;
  354. +             }
  355. +             spl (sr);
  356. +             disposetimeout(this);
  357. +             return;
  358. +         }
  359. +         prev = &cur->next;
  360. +     }
  361. +     spl(sr);
  362. + }
  363. + 
  364. + void ARGS_ON_STACK
  365. + cancelroottimeout(this)
  366. +     TIMEOUT *this;
  367. + {
  368. +     TIMEOUT *cur, **prev;
  369. +     short sr = spl7();
  370.       
  371.       prev = &tlist;
  372.       for (cur = tlist; cur; cur = cur->next) {
  373. !         if (cur == this && (cur->proc == rootproc)) {
  374.               *prev = cur->next;
  375.               if (cur->next) {
  376.                   cur->next->when += this->when;
  377.               }
  378. +             spl (sr);
  379.               disposetimeout(this);
  380. !             return;
  381.           }
  382.           prev = &cur->next;
  383.       }
  384. +     spl(sr);
  385.   }
  386.   
  387.   /*
  388. ***************
  389. *** 170,175 ****
  390. --- 296,302 ----
  391.       long delta;
  392.       void (*evnt) P_((PROC *));
  393.       TIMEOUT *old;
  394. +     short sr;
  395.   
  396.   /* do the once per second things */
  397.       while (our_clock < 0) {
  398. ***************
  399. *** 180,201 ****
  400.           reset_priorities();
  401.       }
  402.   
  403.   /* see if there are outstanding timeout requests to do */
  404.       while (tlist && ((delta = tlist->when) <= 0)) {
  405.           p = tlist->proc;
  406. -         TRACE(("doing timeout code for pid %d", p->pid));
  407.           evnt = tlist->func;
  408.           old = tlist;
  409.           tlist = tlist->next;
  410. -         disposetimeout(old);
  411. -     /* call the timeout function */
  412. -         (*evnt)(p);
  413. - 
  414.   /* if delta < 0, it's possible that the time has come for the next timeout
  415. !    to occur */
  416.           if (tlist)
  417.               tlist->when += delta;
  418.       }
  419.   }
  420.   
  421.   /*
  422. --- 307,335 ----
  423.           reset_priorities();
  424.       }
  425.   
  426. +     sr = spl7();
  427.   /* see if there are outstanding timeout requests to do */
  428.       while (tlist && ((delta = tlist->when) <= 0)) {
  429.           p = tlist->proc;
  430.           evnt = tlist->func;
  431.           old = tlist;
  432.           tlist = tlist->next;
  433.   /* if delta < 0, it's possible that the time has come for the next timeout
  434. !  * to occur.
  435. !  * ++kay: moved this before the timeout fuction is called, in case the
  436. !  * timeout function installes a new timeout. */
  437.           if (tlist)
  438.               tlist->when += delta;
  439. +         spl(sr);
  440. + /* ++kay: debug output at spl7 hangs the system, so moved it here */
  441. +         TRACE(("doing timeout code for pid %d", p->pid));
  442. +         disposetimeout(old);
  443. + 
  444. +     /* call the timeout function */
  445. +         (*evnt)(p);
  446. +         sr = spl7();
  447.       }
  448. +     spl(sr);
  449.   }
  450.   
  451.   /*
  452.